.TH std::layout_right::mapping 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::layout_right::mapping \- std::layout_right::mapping

.SH Synopsis
   Defined in header <mdspan>
   template< class Extents >     (since C++23)
   class layout_right::mapping;

   The class template layout_right::mapping controls how multidimensional indices are
   mapped in a row-major manner to a one-dimensional value representing the offset. The
   mapping has stride 1 at rightmost extent and strides increase right-to-left as the
   products of extents.

   Every specialization of mapping is a LayoutMapping and a TriviallyCopyable type
   which satisfies regular.

   The program is ill-formed if the size of the multidimensional index space Extents()
   is not representable as a value of type Extents::index_type when
   Extents::rank_dynamic() is 0.

.SH Template parameters

   Extents - specifies number of dimensions, their sizes, and which are known at
             compile time. Must be a specialization of std::extents.

.SH Member types

   Member type  Definition
   extents_type Extents
   index_type   extents_type::index_type
   size_type    extents_type::size_type
   rank_type    extents_type::rank_type
   layout_type  std::layout_right

.SH Member objects

   Member name        Definition
   extents_ (private) The extents of type extents_type.
                      (exposition-only member object*)

.SH Member functions

   constructor          constructs a new mapping
                        \fI(public member function)\fP
   operator=            assigns a mapping
                        \fI(public member function)\fP
.SH Observers
   extents              obtains the extents object
                        \fI(public member function)\fP
   required_span_size   returns the required size of the mapping
                        \fI(public member function)\fP
   operator()           maps multidimensional indices into an offset value
                        \fI(public member function)\fP
   is_unique            determines if this mapping is unique (every combination of
   \fB[static]\fP             indexes maps to a different underlying element)
                        \fI(public static member function)\fP
   is_exhaustive        determines if this mapping is exhaustive (every underlying
   \fB[static]\fP             element can be accessed with some combination of indexes)
                        \fI(public static member function)\fP
   is_strided           determines if this mapping is unique (every combination of
   \fB[static]\fP             indexes maps to a different underlying element)
                        \fI(public static member function)\fP
   is_always_unique     determines if this layout mapping is always unique
   \fB[static]\fP             \fI(public static member function)\fP
   is_always_exhaustive determines if this layout mapping is always exhaustive
   \fB[static]\fP             \fI(public static member function)\fP
   is_always_strided    determines if this layout mapping is always strided
   \fB[static]\fP             \fI(public static member function)\fP
   stride               obtains the stride along the specified dimension
                        \fI(public member function)\fP

.SH Non-member functions

                                                 compares this layout mapping with
   operator==                                    other mapping
                                                 \fI(function template)\fP
   submdspan_mapping(std::layout_right::mapping) calculates the mapping and data handle
   (C++26)                                       offset used for subdmspan
                                                 \fI(public member function)\fP

.SH See also

   mapping a layout mapping of layout_left
           \fI(public member class template of std::layout_left)\fP
   mapping a layout mapping of layout_stride
           \fI(public member class template of std::layout_stride)\fP
